#define a_ll a_ll
static inline int a_ll(volatile int *p)
{
	int v;
	// LoongArch64的ll.w指令用于加载链接字，是原子操作的基础
	// 类似于ARM的ldaxr和RISC-V的lr.w.aqrl
	__asm__ __volatile__ ("ll.w %0, %1" : "=r"(v) : "Q"(*p));
	return v;
}

#define a_sc a_sc
static inline int a_sc(volatile int *p, int v)
{
	int r;
	// LoongArch64的sc.w指令用于条件存储字，配合ll.w实现原子操作
	// 类似于ARM的stlxr和RISC-V的sc.w.aqrl
	// 返回值r为0表示成功，非0表示失败，因此返回!r
	__asm__ __volatile__ ("sc.w %0, %2, %1" : "=&r"(r), "=Q"(*p) : "r"(v) : "memory");
	return !r;
}

#define a_barrier a_barrier
static inline void a_barrier()
{
	// LoongArch64使用dbar指令作为内存屏障
	// dbar 0表示完全内存屏障(全序)，等同于其他架构的dmb ish或fence rw,rw
	// LoongArch架构手册定义：dbar 0 = 读读+读写+写读+写写屏障
	__asm__ __volatile__ ("dbar 0" : : : "memory");
}

#define a_cas a_cas
static inline int a_cas(volatile int *p, int t, int s)
{
	int old;
	do {
		old = a_ll(p);
		if (old != t) {
			a_barrier();
			break;
		}
	} while (!a_sc(p, s));
	return old;
}

#define a_ll_p a_ll_p
static inline void *a_ll_p(volatile void *p)
{
	void *v;
	// LoongArch64的ll.d指令用于加载链接双字(64位)，用于指针原子操作
	// 类似于ARM的ldaxr和RISC-V的lr.d.aqrl
	__asm__ __volatile__ ("ll.d %0, %1" : "=r"(v) : "Q"(*(void *volatile *)p));
	return v;
}

#define a_sc_p a_sc_p
static inline int a_sc_p(volatile int *p, void *v)
{
	int r;
	// LoongArch64的sc.d指令用于条件存储双字(64位)，配合ll.d实现指针原子操作
	// 类似于ARM的stlxr和RISC-V的sc.d.aqrl
	__asm__ __volatile__ ("sc.d %0, %2, %1" : "=&r"(r), "=Q"(*(void *volatile *)p) : "r"(v) : "memory");
	return !r;
}

#define a_cas_p a_cas_p
static inline void *a_cas_p(volatile void *p, void *t, void *s)
{
	void *old;
	do {
		old = a_ll_p(p);
		if (old != t) {
			a_barrier();
			break;
		}
	} while (!a_sc_p(p, s));
	return old;
}

#define a_ctz_64 a_ctz_64
static inline int a_ctz_64(uint64_t x)
{
	int n;
	// LoongArch64的ctz.d指令用于计算尾随零的个数(Count Trailing Zeros)
	__asm__("ctz.d %0, %1" : "=r"(n) : "r"(x));
	return n;
}

#define a_clz_64 a_clz_64
static inline int a_clz_64(uint64_t x)
{
	int n;
	// LoongArch64的clz.d指令用于计算前导零的个数(Count Leading Zeros)
	__asm__("clz.d %0, %1" : "=r"(n) : "r"(x));
	return n;
}

#define a_spin a_spin
static inline void a_spin()
{
	// LoongArch64没有专门的自旋等待指令，使用nop作为替代
	// 其他架构可能使用特定指令如ARM的yield或x86的pause
	__asm__ __volatile__("nop" : : : "memory");
}

// LoongArch64特有的原子内存操作函数
// 基于LoongArch64的amswap.w/amswap.d等指令实现

#define a_fetch_add a_fetch_add
static inline int a_fetch_add(volatile int *p, int v)
{
	int old;
	__asm__ __volatile__(
		"amaddl.w %0, %2, %1\n"
		: "=&r"(old), "+A"(*p)
		: "r"(v)
		: "memory");
	return old;
}

#define a_fetch_add_64 a_fetch_add_64
static inline int64_t a_fetch_add_64(volatile int64_t *p, int64_t v)
{
	int64_t old;
	__asm__ __volatile__(
		"amaddl.d %0, %2, %1\n"
		: "=&r"(old), "+A"(*p)
		: "r"(v)
		: "memory");
	return old;
}

#define a_fetch_and a_fetch_and
static inline int a_fetch_and(volatile int *p, int v)
{
	int old;
	__asm__ __volatile__(
		"amand.w %0, %2, %1\n"
		: "=&r"(old), "+A"(*p)
		: "r"(v)
		: "memory");
	return old;
}

#define a_fetch_or a_fetch_or
static inline int a_fetch_or(volatile int *p, int v)
{
	int old;
	__asm__ __volatile__(
		"amor.w %0, %2, %1\n"
		: "=&r"(old), "+A"(*p)
		: "r"(v)
		: "memory");
	return old;
}

#define a_fetch_xor a_fetch_xor
static inline int a_fetch_xor(volatile int *p, int v)
{
	int old;
	__asm__ __volatile__(
		"amxor.w %0, %2, %1\n"
		: "=&r"(old), "+A"(*p)
		: "r"(v)
		: "memory");
	return old;
}

#define a_swap a_swap
static inline int a_swap(volatile int *p, int v)
{
	int old;
	__asm__ __volatile__(
		"amswap.w %0, %2, %1\n"
		: "=&r"(old), "+A"(*p)
		: "r"(v)
		: "memory");
	return old;
}

#define a_swap_p a_swap_p
static inline void *a_swap_p(volatile void *p, void *v)
{
	void *old;
	__asm__ __volatile__(
		"amswap.d %0, %2, %1\n"
		: "=&r"(old), "+A"(*(void *volatile *)p)
		: "r"(v)
		: "memory");
	return old;
}

#define a_crash a_crash
static inline void a_crash()
{
	// LoongArch64使用break指令触发异常，用于实现crash功能
	// 类似于ARM的hlt或x86的ud2
	__asm__ __volatile__("break 0" : : : "memory");
}